export namespace model {
	
	export class BoxInfoReqBody {
	    boxIndex: number;
	    list: number[];
	
	    static createFrom(source: any = {}) {
	        return new BoxInfoReqBody(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.boxIndex = source["boxIndex"];
	        this.list = source["list"];
	    }
	}
	export class BoxesStageEnableReq {
	    fileId: number;
	    enable: boolean;
	    paid: boolean;
	    agentId: string;
	    boxesStage: BoxInfoReqBody[];
	
	    static createFrom(source: any = {}) {
	        return new BoxesStageEnableReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.fileId = source["fileId"];
	        this.enable = source["enable"];
	        this.paid = source["paid"];
	        this.agentId = source["agentId"];
	        this.boxesStage = this.convertValues(source["boxesStage"], BoxInfoReqBody);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class BoxesStageEnableRes {
	    num: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new BoxesStageEnableRes(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.num = source["num"];
	        this.msg = source["msg"];
	    }
	}
	export class Resource {
	    url: string;
	    height: number;
	    weight: number;
	
	    static createFrom(source: any = {}) {
	        return new Resource(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.url = source["url"];
	        this.height = source["height"];
	        this.weight = source["weight"];
	    }
	}
	export class StoreDetail {
	    id: string;
	    name: string;
	    join_time: string;
	    store_type_name: string;
	    site_hot: number;
	    rate: number;
	    phone: string;
	    city_district: string;
	    staff_num: number;
	    active: boolean;
	    province: string;
	    defaultResource: Resource;
	    createBy: string;
	    appointmentCount: number;
	    verifyCount: number;
	    isOpen: boolean;
	    isPaid: boolean;
	    serviceCycle: number;
	
	    static createFrom(source: any = {}) {
	        return new StoreDetail(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.join_time = source["join_time"];
	        this.store_type_name = source["store_type_name"];
	        this.site_hot = source["site_hot"];
	        this.rate = source["rate"];
	        this.phone = source["phone"];
	        this.city_district = source["city_district"];
	        this.staff_num = source["staff_num"];
	        this.active = source["active"];
	        this.province = source["province"];
	        this.defaultResource = this.convertValues(source["defaultResource"], Resource);
	        this.createBy = source["createBy"];
	        this.appointmentCount = source["appointmentCount"];
	        this.verifyCount = source["verifyCount"];
	        this.isOpen = source["isOpen"];
	        this.isPaid = source["isPaid"];
	        this.serviceCycle = source["serviceCycle"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class StoreList {
	    page: number;
	    size: number;
	    total_page: number;
	    total_count: number;
	    is_last_page: boolean;
	    data: StoreDetail[];
	
	    static createFrom(source: any = {}) {
	        return new StoreList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.page = source["page"];
	        this.size = source["size"];
	        this.total_page = source["total_page"];
	        this.total_count = source["total_count"];
	        this.is_last_page = source["is_last_page"];
	        this.data = this.convertValues(source["data"], StoreDetail);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class StoreListReq {
	    page: number;
	    page_size: number;
	    keyword: string;
	    on_state: number;
	
	    static createFrom(source: any = {}) {
	        return new StoreListReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.page = source["page"];
	        this.page_size = source["page_size"];
	        this.keyword = source["keyword"];
	        this.on_state = source["on_state"];
	    }
	}

}

export namespace res {
	
	export class AgentSelectResp {
	    id: string;
	    name: string;
	    phone: string;
	    real_name: string;
	
	    static createFrom(source: any = {}) {
	        return new AgentSelectResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.phone = source["phone"];
	        this.real_name = source["real_name"];
	    }
	}
	export class AgentSelectListResp {
	    list: AgentSelectResp[];
	
	    static createFrom(source: any = {}) {
	        return new AgentSelectListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], AgentSelectResp);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}

}

